MacHack 1993/MacHack 1993.toast/MacHack™ 1987-1992/MacHack™ '90/Other Stuff/Demos ƒ/Word Solution Engine DEMO/Raw Text Files/WSDemo.p

Text File | 1990-06-14 | 57.9 KB | 2,800 lines | [TEXT/MPS ]

          {$M-}
          {$R-}



          PROGRAM   WSTEST;



     USES   MemTypes, QuickDraw, OsIntf, ToolIntf, PackIntf,MacPrint,
             PickerIntf,Script,WSIntf;

{$S  }


    {  THE MENU VARIABLES:

          MENU0         Apple menu     ID 1
          MENU1         File            ID 100
          MENU2         Edit            ID 200
          MENU3         Font            ID 300
          MENU4         Style            ID 400
          MENU5         Point            ID 500
          MENU6         Format            ID 600
          MENU7         Demo            ID 700  }


{  ALERT & DIALOG ID'S  }

    CONST    AboutAlert = 128;        { About Screen }
            MemFailed = 129;        { Memory error }
            SaveChanges = 130;        { Save changes yes/no }
            CantUndo = 131;            { Cannot create UNDO buffer }
            PtSizeDLG = 132;        { Custom point size }
            WrapDLG    =    134;        { Word-wrap characteristics }
            AddOnAlert = 136;        { About the add-ons }
            AskScrap = 140;            { Ask if clipboard should be saved }
            StupidTester = 142;        { Some fool is trying to crash program }
            BadFonts = 144;            { Some wrong fonts kicking around }
            OpenDLG = 4000;            { OPEN dialog }
            ExportDLG = 3000;        { EXPORT text dialog }


TYPE MyWS = RECORD
       WS:WSHandle;                { Handle for this screen }
       vRef:Integer;            { Volume reference }
       fRef:Integer;            { File ref }
       Undo:Integer;            { Last action (used for UNDO) }
       UnSel1:LongInt;            { Undo selection 1 }
       UnSel2:LongInt;            { Undo selection 2 }
       UnSel3:LongInt;            { Last mouse-click }
       vCTL:ControlHandle;        { Vertical scroll }
       hCTL:ControlHandle;        { Horizontal scroll }
       vOffset:LongInt;            { Vertical offset }
       hOffset:LongInt;            { Horizontal offset }
       Change:Boolean;            { Changes yes/no }
     END;

     MyWSPtr = ^MyWS;            { Pointer to the above }
     IntWidths = ARRAY[0..0] OF INTEGER;
     WidTablePtr = ^IntWidths;

VAR WS,UndoWS,ScrapWS:WSHandle;
    FontScrap:FormatHandle;
    CurWS:MyWS;
    R1:Rect;
    LocalMouse:Point;
    MyBounds:LongRect;
    MainWindow,ClipWindow:WindowPtr;
    EV:EventRecord;
    X,CurCursor,ShowCtr,io,MyScrapNum,OpenSelect,ExpSel,AppMsg,nFiles:Integer;
    AppData:AppFile;
    Quit,OpFailed,CXL,MyOwnScrap:Boolean;
    Menu0,Menu1,Menu2,Menu3,Menu4,Menu5,Menu6,Menu7:MenuHandle;
    LastNumChars:LongInt;
    AppleChar,MastSTR:STR255;
    xScrap:pScrapStuff;
    DefFlags:LongInt;

    PHDL:THPrint;
    PStatus:TPRStatus;
    PrintPort:TPPrPort;


PROCEDURE Bomb;
INLINE $A9FF;


PROCEDURE GetXScrap;
VAR TheView:Rect;
    MyBounds:LongRect;

BEGIN
   XScrap:= InfoScrap;
   IF XScrap^.scrapCount <> MyScrapNum
   THEN
   BEGIN
       SetRect(TheView,0,0,512,320);        { Some arbitrary number }
       MyBounds.Left:= 0;
       MyBounds.Top:= 0;
       MyBounds.Right:= 512;
       MyBounds.Bottom:= 320;
       IF ScrapWS <> NIL THEN WSDispose(ScrapWS);
       ScrapWS:= WSScrapToHandle(TheView,MyBounds,0,NIL,NIL);
   END;
   MyScrapNum:= XScrap^.scrapCount;
END;


PROCEDURE PutXScrap;
BEGIN
   IF ScrapWS = NIL THEN EXIT(PutXScrap);
   WSToScrap(ScrapWS);
   XScrap:= InfoScrap;
   MyScrapNum:= XScrap^.scrapCount;
END;


PROCEDURE SetMouse (C:Integer);
VAR CC:CursHandle;
    CCC:Cursor;

BEGIN
   IF C = CurCursor THEN EXIT(SetMouse);
   CurCursor:= C;
   IF CurCursor = 0 THEN InitCursor
   ELSE
   BEGIN
      CC:= GetCursor(C);
      CCC:= CC^^;
      SetCursor(CCC);
   END;
END;


FUNCTION What4Scrap:Boolean;
BEGIN
   What4Scrap:= TRUE;
   IF NOT MyOwnScrap THEN EXIT(What4Scrap);

   IF ScrapWS = NIL THEN EXIT (What4Scrap);
   IF ScrapWS^^.tLength < 100 THEN EXIT(What4Scrap);

   SetMouse(0);
   io:= CautionAlert(AskScrap,NIL);
   CASE io OF

      1: PutXScrap;
      2: What4Scrap:= FALSE;
   END;
END;



PROCEDURE ShowNumChars;                { Shows # of chars per current window }
VAR R:Rect;
    Work1,Work2:LongInt;
    i,n:Integer;
    NumStr:STR255;

      PROCEDURE BCD(Power:LongInt);
      BEGIN
         n:= 48;                { Start with zero }
         REPEAT
            Work1:= Work1-Power;
            n:= n+1;
         UNTIL Work1 < 0;
         Work1:= Work1+Power;
         n:= n-1;

         IF n <> 48 THEN
         BEGIN
            NumStr[i]:= CHR(n);
            i:= i+1;
         END
         ELSE
         IF i > 1
         THEN
         BEGIN
            NumStr[i]:= CHR(n);
            i:= i+1;
         END;
      END;

BEGIN
    IF WS^^.tLength-2 = LastNumChars THEN EXIT(ShowNumChars);

    LastNumChars:= WS^^.tLength-2;
    SetPort(MainWindow);
    TextFont(0);
    TextSize(12);
    TextFace([]);

    R:= CurWS.hCTL^^.contrlRect;
    R.Right:= 120;
    R.Left:= 0;
    EraseRect(R);
    PenSize(1,1);
    PenPat(Black);
    PenMode(PatCopy);
    FrameRect(R);

    Work1:= LastNumChars;
    NumStr:= '9999999';
    i:= 1;
    BCD(1000000);
    BCD(100000);
    BCD(10000);
    BCD(1000);
    BCD(100);
    BCD(10);
    NumStr[i]:= CHR(Work1+48);
    NumStr[0]:= CHR(i);

    MOVETO(R.left+4,R.Bottom-3);
    DrawString(NumStr);
    DrawString(' Chars');
END;

PROCEDURE CaretOff;
BEGIN
   IF MainWindow = NIL THEN EXIT(CaretOff);
   SetPort(MainWindow);
   WSSetCaret(WS,FALSE);
END;


PROCEDURE GetMyWS (W:WindowPtr);  { Sets CurWS and MainWindow }
VAR TempWS:MyWSPtr;

BEGIN
   MainWindow:= W;
   IF MainWindow = NIL THEN Exit(GetMyWS);

   TempWS:= MyWSPtr(GetWRefCon(W));
   IF TempWS = NIL THEN MainWindow:= NIL
   ELSE
   BEGIN
      WS:= TempWS^.WS;
      BlockMove(Ptr(TempWS),Ptr(@CurWS),SizeOf(CurWS));
   END;
END;


PROCEDURE SetMyWS (W:WindowPtr);  { Puts CurWS into Window }
VAR TempWS:MyWSPtr;

BEGIN
   TempWS:= MyWSPtr(GetWRefCon(W));
   BlockMove(Ptr(@CurWS),Ptr(TempWS),SizeOf(CurWS));
END;

PROCEDURE SetChanges(C:Boolean);
BEGIN
   CurWS.Change:= C;
   SetMyWS(MainWindow);
END;


PROCEDURE InvalScrap;
BEGIN
   IF ClipWindow = NIL THEN EXIT(InvalScrap);
   SetPort(ClipWindow);
   InvalRect(ClipWindow^.PortRect);
END;

PROCEDURE ForceUpdate;
FORWARD;


 PROCEDURE ReHabPrint;        { Forces Print Driver to behave itelf }
 VAR Dummy:Boolean;
 BEGIN
    PrClose;
    PrOpen;
    Dummy:= PrValidate(PHDL);
 END;


  FUNCTION Str2Num(nSTR:STR255):Integer;
  VAR Value,X,Y,rRound:Integer;
      iSTR:STR255;

  BEGIN
     Value:= 0;            { Assume nothing }

     iSTR:= nSTR;

     IF Length(iSTR) > 0 THEN
     BEGIN
        IF iSTR[1] = '-'  { IF NEGATIVE }
        THEN iSTR[1]:= '0';

        FOR Y:= 1 TO Length(iSTR) DO
        BEGIN
           X:= ORD(iSTR[Y])-48;          { ASCII-ness = decimal }

           IF (X >= 0) AND (X < 10)
           THEN Value:= Value*10+X;
        END;
     END;

     IF nSTR[1] = '-' { If original was MINUS }
     THEN
     BEGIN
        X:= 0;
        Value:= X-Value;      { Negate }
     END;

     Str2Num:= Value;
  END;


 { Reverse of the above }

 PROCEDURE Num2Str(Num:Integer; VAR S:STR255);
 VAR ZeroFlag:Boolean;
     X,Y,Value:Integer;

     PROCEDURE ASCIIChar(SubVal:Integer);
     VAR D:Integer;

     BEGIN
        D:= 48;         { ASCII ZERO }
        REPEAT
           Value:= Value-SubVal;
           D:= D+1;
        UNTIL Value < 0;
        Value:= Value+SubVal;
        D:= D-1;
        IF D > 48 THEN ZeroFlag:= FALSE;  { Do not suppress zeros }

        IF NOT ZeroFlag THEN
        BEGIN
           S[Y]:= CHR(D);       { Add a char }
           Y:= Y+1;
        END;
     END;

 BEGIN

    S:= '      ';     { Init string }
    ZeroFlag:= TRUE;     { Suppress zeros }
    Y:= 1;         { Index into output string }

    Value:= NUM;

    IF Num < 0  { If negative number } THEN
    BEGIN
       S[1]:= '-';     { Minus sign }
       Y:= 2;         { Index 2nd char }
       Value:= 0;
       Value:= Value-Num;  { Reverse polarity }
    END;

    ASCIICHAR(10000);
    ASCIICHAR(1000);
    ASCIICHAR(100);
    ASCIICHAR(10);

    S[Y]:= CHR(Value+48);       { = last digit }

    S[0]:= CHR(Y);           { .. and set string length }
 END;



FUNCTION NumProc(TheDLG:DialogPtr; VAR EV:EventRecord;
                    VAR ItemAction:Integer):Boolean;

VAR X,DummyType:Integer;
    DummyRect:RECT;
    ItemHDL:Handle;
    K:Packed Array[0..1] OF CHAR;

BEGIN
   NumProc:= FALSE;          { I need no special handling }

   IF (EV.What = 8) AND (BitAND(EV.Modifiers,1) = 1) { If ACTIVATE }
   THEN
   BEGIN
      { Time to set up default Pic Props }

      GetDItem(TheDLG,3,DummyType,ItemHDL,DummyRect);
      SetIText(ItemHDL,MastSTR);
      SelIText(TheDLG,3,0,Length(MastSTR));    { .. and select text }
   END
   ELSE
   IF (EV.What = 3) OR (EV.What = 5)  { IF KEYSTROKE }
   THEN
   BEGIN
      X:= LoWord(EV.Message);
      K[0]:= CHR(X);
      IF K[0] = CHR(13)     { IF CR }
      THEN
      BEGIN
         ItemAction:= 1;
         NumProc:= TRUE;
      END;
   END;
END;



 { The following function returns a numeric value entered by user }

  FUNCTION NumDialog(DlgID:Integer; VAR Value:Integer):Boolean;


  VAR MakePtr:DialogPtr;
      EndAction,ACCEPT:Boolean;
      ItemAction,iType,X,Y:Integer;
      ItemHDL:Handle;
      iRect:RECT;
      iSTR:STR255;

  BEGIN
     Num2STR(Value,MastSTR);
     CaretOff;

     MakePtr:= GetNewDialog(DlgID,NIL,Pointer(-1));

     EndAction:= FALSE;      { Flag TRUE when done }
     ACCEPT:= TRUE;      { Assume accepted }

     REPEAT

        ModalDialog(@NumProc,ItemAction);

        CASE ItemAction OF

           1: { OK }
              EndAction:= TRUE;

           2: { CANCEL }
              BEGIN
                 EndAction:= TRUE;
                 ACCEPT:= FALSE;
              END;
        END; { of CASE }

     UNTIL EndAction;

     IF ACCEPT { If User clicked "OK" } THEN
     BEGIN
        GetDItem(MakePtr,3,iType,ItemHDL,iRect);   { Get TEXT ITEM }
        GetIText(ItemHDL,iSTR);

        Value:= Str2Num(iSTR);       { Translate string to number }

     END;

     DisposDialog(MakePtr);
     NumDialog:= ACCEPT;   { Returns CANCEL or not }
  END;





FUNCTION WrapProc(TheDLG:DialogPtr; VAR EV:EventRecord;
                    VAR ItemAction:Integer):Boolean;

VAR X,DummyType:Integer;
    DummyRect:RECT;
    ItemHDL1,ItemHDL2:Handle;
    K:Packed Array[0..1] OF CHAR;

BEGIN
   WrapProc:= FALSE;          { I need no special handling }

   IF (EV.What = 8) AND (BitAND(EV.Modifiers,1) = 1) { If ACTIVATE }
   THEN
   BEGIN
      GetDItem(TheDLG,3,DummyType,ItemHDL1,DummyRect);
      GetDItem(TheDLG,4,DummyType,ItemHDL2,DummyRect);
      SetCTLValue(ControlHandle(ItemHDL1),0);
      SetCTLValue(ControlHandle(ItemHDL2),0);

      IF DefFlags = NoWrap THEN SetCTLValue(ControlHandle(ItemHDL2),1)
      ELSE SetCTLValue(ControlHandle(ItemHDL1),1);
   END
   ELSE
   IF (EV.What = 3) OR (EV.What = 5)  { IF KEYSTROKE }
   THEN
   BEGIN
      X:= LoWord(EV.Message);
      K[0]:= CHR(X);
      IF K[0] = CHR(13)     { IF CR }
      THEN
      BEGIN
         ItemAction:= 1;
         WrapProc:= TRUE;
      END;
   END;
END;


 { The following function returns the type of word-wrapping to do }

 FUNCTION GetWrapType:Boolean;

  VAR MakePtr:DialogPtr;
      EndAction,ACCEPT:Boolean;
      ItemAction,iType:Integer;
      ItemHDL:Handle;
      iRect:RECT;

  BEGIN
     MakePtr:= GetNewDialog(134,NIL,Pointer(-1));

     EndAction:= FALSE;      { Flag TRUE when done }
     ACCEPT:= TRUE;      { Assume accepted }
     SetMouse(0);

     REPEAT

        ModalDialog(@WrapProc,ItemAction);

        CASE ItemAction OF

           1: { OK }
              EndAction:= TRUE;

           2: { CANCEL }
              BEGIN
                 EndAction:= TRUE;
                 ACCEPT:= FALSE;
              END;

           3: BEGIN
                 GetDItem(MakePtr,3,iType,ItemHDL,iRect);
                 SetCTLValue(ControlHandle(ItemHDL),1);
                 GetDItem(MakePtr,4,iType,ItemHDL,iRect);
                 SetCTLValue(ControlHandle(ItemHDL),0);
              END;

           4: BEGIN
                 GetDItem(MakePtr,3,iType,ItemHDL,iRect);
                 SetCTLValue(ControlHandle(ItemHDL),0);
                 GetDItem(MakePtr,4,iType,ItemHDL,iRect);
                 SetCTLValue(ControlHandle(ItemHDL),1);
              END;


        END; { of CASE }

     UNTIL EndAction;

     IF ACCEPT { If User clicked "OK" } THEN
     BEGIN
        GetDItem(MakePtr,3,iType,ItemHDL,iRect);   { Get TEXT ITEM }
        IF GetCTLValue(ControlHandle(ItemHDL)) = 1
        THEN DefFlags:= 0
        ELSE DefFlags:= NoWrap;
     END;

     DisposDialog(MakePtr);
     GetWrapType:= ACCEPT;   { Returns CANCEL or not }
  END;



PROCEDURE SetFontUndo;
BEGIN
    WSGetSelect(WS,CurWS.unSel1,CurWS.unSel2);
    IF FontScrap <> NIL THEN DisposHandle(Handle(FontScrap));

    FontScrap:= WSCopyFormat(WS);
    CurWS.Undo:= 1;                { Format change }
END;


PROCEDURE ShowClipBoard;
BEGIN
   IF (ClipWindow <> NIL) AND (ClipWindow = FrontWindow)
   THEN
   BEGIN
      DisposeWindow(ClipWindow);
      ClipWindow:= NIL;
   END
   ELSE
   BEGIN
       IF ClipWindow = NIL
       THEN ClipWindow:= GetNewWindow(257,NIL,Pointer(-1))
       ELSE SelectWindow(ClipWindow);
          InvalScrap;    { Cause clipboard to draw }
   END;
END;



{ GetMaxScroll -- returns maximum scroll values for h/v }
PROCEDURE GetMaxScroll (VAR hMax,vMax:LongInt);
VAR Work1,Work2:LongInt;
    TheBounds:LongRect;

BEGIN
    WSGetScrollState(WS,CurWS.hOffset,CurWS.vOffset);

    WSGetBounds(WS,TheBounds);                    { So I know how far text goes }
    Work1:= TheBounds.Bottom-TheBounds.Top;        { Height of bounds }
    Work2:= WS^^.tRect.Top;                    { Top edge of view }
    Work1:= Work1+Work2;                    { Bounds if it never scrolled }
    Work2:= WS^^.tRect.Bottom;                { Bottom of vis edge }

    vMax:= Work1-Work2+32;                    { = maximum v-scroll }
    IF vMax < 0 THEN vMax:= 0;                { Can't have negative MAX }

    Work1:= TheBounds.Right-TheBounds.Left;        { Width of bounds }
    Work2:= WS^^.tRect.Left;                    { Left edge of view }
    Work1:= Work1+Work2;                    { Bounds if it never scrolled }
    Work2:= WS^^.tRect.Right;                { Right of vis edge }

    hMax:= Work1-Work2;                        { = maximum v-scroll }
    IF hMax < 0 THEN hMax:= 0;                { Can't have negative MAX }

END;


PROCEDURE MakeNewControls(W:WindowPtr);
VAR R1,R2:Rect;
BEGIN
   R1:= W^.PortRect;
   R2:= R1;
   R1.Left:= R1.Right-16;
   R1.Bottom:= R1.Bottom-13;
   OffsetRect(R1,1,-1);

   R2.Top:= R2.Bottom-16;
   R2.Right:= R2.Right-13;
   OffsetRect(R2,-1,1);

   R2.Left:= R2.Left+120;                { So I can show "chars.." }

   CurWS.vCTL:= NewControl(W,R1,' ',FALSE,0,0,720,16,0);
   CurWS.hCTL:= NewControl(W,R2,' ',FALSE,0,0,64,16,0);

END;


PROCEDURE SetMaxScroll;  { Sets the two scroll bars to maximum scroll values }
VAR hMax,vMax,SH,SV:LongInt;
    h,V,OldH,OldV,X:Integer;
BEGIN
    GetMaxScroll(hMax,vMax);            { Obtain max pixels }
    OldH:= GetCTLMax(CurWS.hCTL);
    OldV:= GetCTLMax(CurWS.vCTL);

    H:= hMax DIV 8;
    V:= vMax DIV 8;
    SetCTLMax(CurWS.vCTL,V);
    SetCTLMax(CurWS.hCTL,H);

    IF (OldH <> H) OR (OldV <> V)
    THEN
    BEGIN
        X:= CurWS.VOffset DIV 8;
        SetCTLValue(CurWS.vCTL,X);

        X:= CurWS.hOffset DIV 8;
        SetCTLValue(CurWS.hCTL,X);
    END;

    IF OldH <> H
    THEN
    BEGIN
       IF (H = 0) AND (OldH <> 0) THEN HiliteControl(CurWS.hCTL,255)
       ELSE
       IF (OldH = 0) AND (H <> 0) THEN HiliteControl(CurWS.hCTL,0);
    END;

    IF OldV <> V
    THEN
    BEGIN
       IF (V = 0) AND (OldV <> 0) THEN HiliteControl(CurWS.vCTL,255)
       ELSE
       IF (OldV = 0) AND (V <> 0) THEN HiliteControl(CurWS.vCTL,0);
    END;

    IF (H = 0) OR (V = 0) THEN
    BEGIN
       WSGetScrollState(WS,SH,SV);
       IF H <> 0 THEN SH:= 0;        { Unaffected }
       IF V <> 0 THEN SV:= 0;        { Unaffected }

       IF (SH <> 0) OR (SV <> 0) THEN WSScroll(WS,SH,SV);
     { THE ABOVE FIXES A PROBLEM WHERE SCREEN IS PARTIALLY SCROLLED YET
         SCROLL BARS ARE DISABLED ! }
    END;
END;

PROCEDURE ForceScroll;
FORWARD;

PROCEDURE ReDisplay;                { Called when WS needs updating }
BEGIN
   WSBitMapDisplay(WS,0,SrcCopy,TRUE);
   ForceScroll;
   SetMaxScroll;
END;


 { MasterScroll -- scrolls h/v pixels. It also fixes H,V amounts so they
  do not scroll the window too far up or down. Since H & V are VAR params,
  those who call this now have the actual scrolled amounts }

 PROCEDURE MasterScroll (VAR h,v:LongInt);
 VAR hMax,vMax,OldVMax,OldHMax,hMove,vMove:LongInt;
     X:Integer;

     PROCEDURE FixScroll (VAR Value:LongInt; Base,Max:LongInt);
     VAR Work:LongInt;
     BEGIN
        Work:= Base-Value;    { Where it WILL wind up }
        IF Work < 0 THEN Value:= Base  { Can only subtract what's left }
        ELSE
        IF Work > Max  { If gone too far }
        THEN Value:= Base-Max;   { Scroll negative diff between current & Max }
     END;

 BEGIN
    GetMaxScroll(hMax,vMax);
    OldHMax:= hMax;
    OldVMax:= vMax;                    { Save in case it changed on fly }

    FixScroll(h,CurWS.hOffset,hMax);
    FixScroll(v,CurWS.vOffset,vMax);

    IF (H = 0) AND (V = 0) THEN EXIT(MasterScroll);   { Nothing to do! }

{ Record the current position of tBounds }

    hMove:= WS^^.tBounds.Left;
    vMove:= WS^^.tBounds.Top;

    WSScroll(WS,h,v);

    ClipRect(MainWindow^.PortRect);

    GetMaxScroll(hMax,vMax);
    IF (hMax <> OldHMax) OR (vMax <> OldVMax)
    THEN SetMaxScroll;                        { It changed during display! }

    WSGetScrollState(WS,CurWS.hOffset,CurWS.vOffset);

    X:= CurWS.VOffset DIV 8;
    SetCTLValue(CurWS.vCTL,X);

    X:= CurWS.hOffset DIV 8;
    SetCTLValue(CurWS.hCTL,X);

    SetMyWS(MainWindow);

 END;


PROCEDURE ForceScroll;        { Determines whether or not to scroll to caret }
VAR L:LongRect;
    e,b,v,h:LongInt;
    Pix:Integer;
BEGIN
   WSGetSelect(WS,e,b);
   IF e <> b THEN EXIT(ForceScroll);        { Never if selection }

   WSLine2Rect(WS,L,Pix);                    { See where line is }
   v:= 0;                                    { Assume no v-scroll }
   h:= 0;                                    { Assume no H-scroll }

   e:= WS^^.tRect.Top;
   b:= WS^^.tRect.Bottom;                    { Converts to longints }

   IF L.Top < e      { If line's top above view }
   THEN v:= e-L.Top+16        { Then scroll this much }
   ELSE
   IF L.Bottom > b  { If line's bottom is below view }
   THEN v:= b-L.Bottom-16;    { Then scroll this much }

{ See if H-SCROLL }

   e:= Pix;                                    { Convert to longint }
   L.Left:= L.Left+e;                        { Where the edge is }
   e:= WS^^.tRect.Left;
   b:= WS^^.tRect.Right;

   IF L.Left < e      { If line's left of view }
   THEN h:= e-L.Left+16        { Then scroll this much }
   ELSE
   IF L.Left > b         { If line's right of view }
   THEN h:= b-L.Left-16;    { Then scroll this much }

   IF (V <> 0) OR (H <> 0)  { If I have something }
   THEN
   BEGIN
      SetMaxScroll;
      MasterScroll(H,V);
   END;
END;


PROCEDURE DoImport;  { IMPORT A TEXT FILE }
VAR FileReply:SFReply;
     FTypes:SFTypeList;
     P:Point;
     FileName:STR255;
     Error,fVol,fRef:Integer;
     CH:Handle;
     fSize,S1,S2:LongInt;
     WSP:WSHandle;
     MyView:Rect;
     MyBounds:LongRect;
     CurFormat:FormatRec;

BEGIN
     P.H:= 100;
     P.V:= 80;
     FTypes[0]:= 'TEXT';

     CaretOff;

     SFGetFile(P,' ',NIL,1,FTypes,NIL,FileReply);

     IF NOT FileReply.Good THEN EXIT(DoImport);
     SetMouse(4);
     ForceUpdate;
     GetMyWS(FrontWindow);
     SetPort(MainWindow);

     FileName:= FileReply.fName;
     fVol:= FileReply.vRefNum;

     Error:= FSOpen(FileName,fVol,fRef);

     Error:= GetEOF(fRef,fSize);         { Get logical file size }

     CH:= NewHandle(fSize);

     IF OpFailed THEN EXIT(DoImport);

     HLOCK(CH);

     Error:= FSRead(fRef,fSize,Pointer(@CH^^));
     HUNLOCK(CH);

     Error:= FSClose(fRef);

     SetRect(MyView,0,0,512,300);        { Set to any old thing }
     MyBounds.Left:= 0;
     MyBounds.Top:= 0;
     MyBounds.Right:= 680;
     MyBounds.Bottom:= 300;

     CurFormat:= WS^^.tFmt;                { Get current format of WS }
     WSP:= WSText2New (CH,MyView,MyBounds,0,NIL,@CurFormat);
     DisposHandle(CH);

     IF OpFailed THEN EXIT(DoImport);

     WSGetSelect(WS,S1,S2);

     IF WSPaste(WSP,WS) THEN ReDisplay;

     WSGetSelect(WS,fSize,S2);    { So I can do UNDO }
     CurWS.Undo:= 2;
     CurWS.unSel1:= S1;
     CurWS.unSel2:= S2;
     CurWS.Change:= TRUE;
     SetMyWS(MainWindow);
     WSDispose(WSP);
 END;


{ EXPORTING TEXT }

{ This is the DialogProc for EXPORT }

FUNCTION ExpGet(Item:Integer; theDialog:DialogPtr):Integer;
VAR CT1,CT2:Handle;
    T,X,Val:Integer;
    R:RECT;

BEGIN
   ExpGet:= ITEM;

   IF ITEM = -1 THEN  { TIME TO INITIALIZE! }
   BEGIN
      FOR X:= 9 TO 10 DO
      BEGIN
         GetDItem(theDialog,9,T,CT1,R);
         IF ExpSel = 1 THEN Val:= 1
         ELSE Val:= 0;
         SetCTLValue(ControlHandle(CT1),Val);

         IF ExpSel = 3  { IF IMPOSSIBLE TO SELECT }
         THEN HiliteControl(ControlHandle(CT1),255);

         GetDItem(theDialog,10,T,CT1,R);
         IF ExpSel <> 1 THEN Val:= 1
         ELSE Val:= 0;
         SetCTLValue(ControlHandle(CT1),Val);
      END;
   END
   ELSE
   BEGIN
      IF (Item = 9) OR (Item = 10) THEN
      BEGIN
         FOR X:= 9 TO 10 DO
         BEGIN
            GetDItem(theDialog,X,T,CT1,R);
            IF X = Item THEN Val:= 1 ELSE Val:= 0;
            SetCTLValue(ControlHandle(CT1),Val);  { Set if THIS FILE  }
         END;

         ExpSel:= Item;
      END
   END;
END;



Procedure DoExport;

VAR FileReply:SFReply;
     FTypes:SFTypeList;
     P:Point;
     FileName:STR255;
     Error,fVol,fRef:Integer;
     CH:Handle;
     fSize,S1,S2:LongInt;

 BEGIN
    CaretOff;

    WSGetSelect(WS,S1,S2);

    IF S1 = S2 THEN ExpSel:= 3
    ELSE ExpSel:= 1;

    P.H:= 80;
    P.V:= 70;

    SFPPutFile(P,'Save Text-Only As:','Untitled',@ExpGet,FileReply,ExportDLG,
                    NIL);

    ForceUpdate;
    GetMyWS(FrontWindow);

    IF FileReply.Good THEN
    BEGIN
       FileName:= FileReply.fName;

       IF ExpSel = 1  { Selected Text Only }
       THEN CH:= WSGetSelText(WS)
       ELSE CH:= WSGetText(WS);

       IF OpFailed THEN EXIT(DoExport);

       SetMouse(4);
       fVol:= FileReply.vRefNum;

       Error:= FSDelete(FileName,fVol);  { Delete any old }
       Error:= Create(FileName,fVol,'WSDP','TEXT');
       Error:= FSOpen(FileName,fVol,fRef);

       fSize:= GetHandleSize(CH);    {         Size of handle }
       HLOCK(Handle(CH));                       { Lock down for write }

       Error:= FSWRITE(fRef,fSize,Pointer(@CH^^));

       DisposHandle(CH);
       Error:= FlushVol(NIL,fVol);

       Error:= FSCLOSE(fRef);

       InitCursor;
    END;
 END;


PROCEDURE FixBadFonts;
VAR Pos,Count,WSize:LongInt;
    Fmt:FormatRec;
    F1,F2,F3:STR255;
    P:Fixed;
    i,x,ps:Integer;
    Alerted:Boolean;

    FUNCTION FindFont:Boolean;
    VAR    i,v:Integer;

    BEGIN
       v:= CountMItems(MENU3);
       FindFont:= TRUE;            { Assume font exists }
       FOR i:= 1 TO V DO
       BEGIN
          GetItem(Menu3,i,F2);
          IF F1 = F2 THEN EXIT(FindFont);
       END;

       FindFont:= FALSE;
    END;

BEGIN
    WSize:= WS^^.tLength;
    Pos:= 0;
    Alerted:= FALSE;
    GetFontName(1,F3);                { Application font }
    REPEAT
       x:= WSFindFormatRec(WS,Pos,Count,Fmt);
       F1:= Fmt.fName;
       IF NOT FindFont
       THEN
       BEGIN
          IF NOT Alerted THEN
          BEGIN
             SetMouse(0);
             x:= CautionAlert(BadFonts,NIL);
          END;
          Alerted:= TRUE;
          WSFixFonts(WS,F1,F3,LongInt(0),LongInt(0)); { Fix NAME only }
       END
       ELSE
       BEGIN
          GetFNum(F1,X);        { Find font num }
          ps:= HiWord(LongInt(Fmt.fPoint));
          p:= FixRatio(ps,1);
          IF NOT RealFont(X,ps) THEN i:= 0 ELSE i:= 1;
          IF Fmt.fReal = 0 THEN X:= 0 ELSE X:= 1;

          X:= X+i;
          IF X = 1  { IF not noth real or both unreal }
          THEN WSFixFonts(WS,F1,'',p,LongInt(0));
       END;

       Pos:= Pos+Count;
    UNTIL Pos >= WSize;
END;



PROCEDURE OpenMain(UseWS:WSHandle; Fmt:FormatPtr);
    { Opens a window and creates a new WS }
VAR TempWS:MyWSPtr;
    TheView,TheBounds:Rect;
    GH,GV:Integer;

BEGIN
    MainWindow:= GetNewWindow(256,NIL,Pointer(-1));

    IF UseWS = NIL
    THEN
    BEGIN  { Wants a new one }
        ShowWindow(MainWindow);
        SetPort(MainWindow);
        MakeNewControls(MainWindow);

        TheView:= MainWindow^.PortRect;                  { Default to vis area }
        TheView.Right:= CurWS.vCTL^^.contrlRect.Left; { This becomes right edge }
        TheView.Bottom:= CurWS.hCTL^^.contrlRect.Top; { Becomes bottom }

        TheBounds:= TheView;                        { Make a copy }
        InsetRect(TheBounds,4,2);                    { So it looks nicer }
        TheView.Left:= TheView.Left+4;                { View should never be > bounds }
        MyBounds.Left:= TheBounds.Left;                { Translate to longInt }
        MyBounds.Top:= TheBounds.Top;
        MyBounds.Right:= TheBounds.Right;
        MyBounds.Bottom:= TheBounds.Bottom;

        WS:= WSNew(TheView,MyBounds,DefFlags,NIL,Fmt);
    END
    ELSE
    BEGIN
       WS:= UseWS;
       TheView:= MainWindow^.PortRect;
       TheView.Right:= TheView.Right-15;
       TheView.Bottom:= TheView.Bottom-15;

       GH:= TheView.Right-WS^^.tRect.Right;
       GV:= TheView.Bottom-WS^^.tRect.Bottom;

       IF (GH <> 0) OR (GV <> 0)
       THEN
       BEGIN
           GH:= WS^^.tRect.Right+15;
           GV:= WS^^.tRect.Bottom+15;
           SizeWindow(MainWindow,GH,GV,FALSE);     { So it matches original file }
       END;

       ShowWindow(MainWindow);
       SetPort(MainWindow);
       FixBadFonts;
       MakeNewControls(MainWindow);
    END;

    TempWS:= MyWsPtr(NewPtr(SizeOf(CurWS)));
    TempWS^.WS:= WS;
    TempWS^.Change:= FALSE;
    TempWS^.fRef:= 0;
    TempWS^.vRef:= 0;
    TempWS^.Undo:= 0;
    TempWS^.unSel1:= 0;
    TempWS^.unSel2:= 0;
    TempWS^.unSel3:= 0;
    TempWS^.hOffset:= 0;
    TempWS^.vOffset:= 0;
    TempWS^.vCTL:= CurWS.vCTL;
    TempWS^.hCTL:= CurWS.hCTL;
    SetWRefCon(MainWindow,LongInt(TempWS));
    BlockMove(Ptr(TempWS),Ptr(@CurWS),SizeOf(CurWS));
END;


PROCEDURE MenuEnable;   { Called prior to Track menus }
VAR i:Integer;
    S1,S2:LongInt;

    PROCEDURE DisableAll(M:MenuHandle);
    VAR i:Integer;
    BEGIN
       FOR i:= 1 TO 16 DO DisableItem(M,i);
    END;

    PROCEDURE EnableAll(M:MenuHandle);
    VAR i:Integer;
    BEGIN
       FOR i:= 1 TO 16 DO EnableItem(M,i);
    END;


BEGIN
    GetMyWS(FrontWindow);

    IF MainWindow = NIL
    THEN
    BEGIN
       EnableAll(Menu1);
       EnableAll(Menu2);
       DisableAll(Menu3);
       DisableAll(Menu4);
       DisableAll(Menu5);
       DisableAll(Menu6);
       DisableAll(Menu7);

       DisableItem(Menu1,3);
       DisableItem(Menu1,4);
       DisableItem(Menu1,5);
       DisableItem(Menu1,7);
       DisableItem(Menu1,8);
       DisableItem(Menu1,11);            { No Print }

       DisableItem(Menu1,6);
       DisableItem(Menu1,9);
    END
    ELSE
    BEGIN
       EnableAll(Menu1);
       EnableAll(Menu2);
       EnableAll(Menu3);
       EnableAll(Menu4);
       EnableAll(Menu5);
       EnableAll(Menu6);
       EnableAll(Menu7);

       IF CurWS.Undo = 0 THEN DisableItem(Menu2,1);
       WSGetSelect(WS,S1,S2);
       IF S1 = S2
       THEN
       BEGIN
          DisableItem(Menu2,3);        { No Cut }
          DisableItem(Menu2,4);        { No copy }
          DisableItem(Menu2,6);        { No Clear }
       END;

       XScrap:= InfoScrap;
       IF (ScrapWS = NIL) AND (XScrap^.scrapCount = MyScrapNum)
       THEN DisableItem(Menu2,5);

       IF WSColorEnable THEN EnableItem(Menu4,10)
       ELSE DisableItem(Menu4,10);
    END;
END;


PROCEDURE SetRealFonts (fName:STR255);
VAR fNum:Integer;


     PROCEDURE MarkItem (m,s:Integer);
     BEGIN
         IF RealFont(fNum,s) THEN SetItemStyle(Menu5,m,[OUTLINE])
         ELSE SetItemStyle(Menu5,m,[]);
     END;

BEGIN
   GetFNum(fName,fNum);                { Get font number }
   MarkItem(1,6);
   MarkItem(2,9);
   MarkItem(3,10);
   MarkItem(4,12);
   MarkItem(5,14);
   MarkItem(6,16);
   MarkItem(7,18);
   MarkItem(8,20);
   MarkItem(9,22);
   MarkItem(10,24);
END;


PROCEDURE MarkMenus;
VAR i,v,TrueStyle,AnyStyle:Integer;
    Dummy:Boolean;
    fName,mName:STR255;
    pSize:Fixed;
    AllSpaces,AnySpaces,UserSpaces:LongInt;
    Fmt:FormatRec;

BEGIN
   mName:= 'Can t Undo';
   mName[4]:= CHR(39);            { Apost. }

   GetMyWS(FrontWindow);

   IF (ClipWindow <> NIL) AND (FrontWindow = ClipWindow)
   THEN SetItem(MENU2,9,'Hide Clipboard')
   ELSE SetItem(MENU2,9,'Show Clipboard');

   IF MainWindow <> NIL
   THEN
   BEGIN
      { There is an opened WSHandle }
      { Edit }

      IF CurWS.Undo < 9
      THEN
      BEGIN
         CASE CurWS.Undo OF

            1: mName:= 'Undo Format Change';
            2: mName:= 'Undo Import';
            3: mName:= 'Undo Cut';
            4: mName:= 'Undo Copy';
            5: mName:= 'Undo Paste';
            6: mName:= 'Undo Clear';
            7: mName:= 'Undo Selection';
            8: mName:= 'Undo Backspace';
         END;
      END
      ELSE mName:= 'Undo Typing';

      SetItem(Menu2,1,mName);

{ Format }

       v:= WSGetJust(WS);
       FOR i:= 0 TO 3 DO
       BEGIN
           IF i = v THEN CheckItem(Menu6,i+1,TRUE)
           ELSE CheckItem(Menu6,i+1,FALSE);
       END;

{ Style }

       FOR i:= 1 TO 10 DO CheckItem(Menu4,i,FALSE);        { Remove all checkmarks }
       Dummy:= WSGetStyle(WS,TrueStyle,AnyStyle);

       IF (TrueStyle = 0) AND (AnyStyle = 0)  { If both are zero }
       THEN CheckItem(Menu4,1,TRUE)
       ELSE
       BEGIN
          v:= 1;            { To test bits }
          FOR i:= 2 TO 10 DO
          BEGIN
             IF BitAnd(TrueStyle,v) = v
             THEN CheckItem(Menu4,i,TRUE);
             v:= v*2;
          END;
       END;

{ Font }

       v:= CountMItems(MENU3);
       FOR i:= 1 TO v DO CheckItem(Menu3,i,FALSE); { Remove all checkmarks }
       fName:= ' ';                { Initialize pascal string }

       IF WSGetFont(WS,fName)   { If all fonts identical }
       THEN
       BEGIN
           i:= 1;
           REPEAT
              GetItem(Menu3,i,mName);
              IF mName = fName
              THEN
              BEGIN
                 CheckItem(Menu3,i,TRUE);
                 i:= v+1;                { Forces loop to terminate }
              END
              ELSE i:= i+1;
           UNTIL (i > v);

           SetRealFonts(fName);            { Outline appropriate menus }
       END
       ELSE
       BEGIN
          For i:= 1 To 10 DO SetItemStyle(Menu5,i,[]);  { NO OUTLINES }
       END;


{ Point Size }

       FOR i:= 1 To 16 DO CheckItem(Menu5,i,FALSE);

       IF WSGetPoint(WS,pSize)
       THEN
       BEGIN
          v:= HiWord(LongInt(pSize));
          i:= 11;                { Assume none are selected }
          CASE v OF
             6: i:= 1;
             9: i:= 2;
             10: i:= 3;
             12: i:= 4;
             14: i:= 5;
             16: i:= 6;
             18: i:= 7;
             20: i:= 8;
             22: i:= 9;
             24: i:= 10;
          END;

          CheckItem(Menu5,i,TRUE);

  { Use Styles }

            FOR i:= 1 TO 16 DO CheckItem(Menu7,i,FALSE);

          UserSpaces:= WSGetUserSpace (WS,AllSpaces,AnySpaces);

          i:= LoWord(AllSpaces);

          IF BitAnd(i,1) = 1 THEN CheckItem(MENU7,3,TRUE);
          IF BitAnd(i,2) = 2 THEN CheckItem(MENU7,4,TRUE);
          IF BitAnd(i,8) = 8 THEN CheckItem(MENU7,5,TRUE);
          IF BitAnd(i,16) = 16 THEN CheckItem(MENU7,6,TRUE);
          IF BitAnd(i,32) = 32 THEN CheckItem(MENU7,7,TRUE);
          IF BitAnd(i,64) = 64 THEN CheckItem(MENU7,8,TRUE);

       END;
   END
   ELSE SetItem(Menu2,1,mName);

END;



{ The following is a filter to select either "standard" or "text" files. }

FUNCTION ImpFilter(P:ParmBlkPtr):Boolean;
BEGIN

 { This is the I/O filter for IMPORT }

   CASE OpenSelect OF

      1: IF (P^.ioFlFndrInfo.fdType = 'WSDC')  { Our own invention }
          THEN ImpFilter:= FALSE
          ELSE ImpFilter:= TRUE;

      2:   IF P^.ioFlFndrInfo.fdType = 'TEXT'    { Raw TEXT }
            THEN ImpFilter:= FALSE
            ELSE ImpFilter:= TRUE;
   END;
END;


{ This is the DialogProc for IMPORT }

FUNCTION ImpGet(Item:Integer; theDialog:DialogPtr):Integer;
VAR CT1,CT2:Handle;
    T,X,Val:Integer;
    R:RECT;
    ByCode:STR255;

BEGIN
   ImpGet:= ITEM;

   IF ITEM = -1 THEN  { TIME TO INITIALIZE! }
   BEGIN
      FOR X:= 1 TO 2 DO
      BEGIN
         GetDItem(theDialog,X+10,T,CT1,R);
         IF X = OpenSelect  { If this one selected }
         THEN Val:= 1
         ELSE Val:= 0;
         SetCTLValue(ControlHandle(CT1),Val);
      END;
   END
   ELSE
   BEGIN
      IF (Item > 10) AND (Item < 13) THEN
      BEGIN
         FOR X:= 11 TO 12 DO
         BEGIN
            GetDItem(theDialog,X,T,CT1,R);
            IF X = Item THEN Val:= 1 ELSE Val:= 0;
            SetCTLValue(ControlHandle(CT1),Val);  { Set if THIS FILE  }
         END;

         OpenSelect:= Item-10;
         ImpGet:= 101;        { Force a re-display }
      END
   END;
END;


PROCEDURE MakeMonaco (VAR Fmt:FormatRec);
VAR x:Integer;
BEGIN
   Fmt.Pos:= 0;
   Fmt.UserProcs:= NIL;
   Fmt.fReal:= 1;
   FOR X:= 1 TO 31 DO Fmt.fName[X]:= CHR(0);
   Fmt.fName:= 'Monaco';
   Fmt.fStyle:= 0;
   Fmt.fPoint:= FixRatio(9,1);
   Fmt.fgColor.Red:= 0;
   Fmt.fgColor.Green:= 0;
   Fmt.fgColor.Blue:= 0;
   Fmt.Txr:= 0;
   Fmt.cExtra:= LongInt(0);
   Fmt.Leading:= 0;
   Fmt.UserSpace:= 0;
END;

{ Open a unique file }
 FUNCTION OpenFile(inName:STR255; inVol:Integer):Boolean;
 VAR FileReply:SFReply;
     fSize,Position,Count:LongInt;
     Fmt:FormatRec;
     Error,Error1,fRef,fVol,x:Integer;
     FileName:STR255;
     DataHandle:Handle;
     cDataHandle:Handle;
     FTypes:SFTypeList;
     P:Point;

 BEGIN
     P.H:= 40;
     P.V:= 60;
     FTypes[0]:= 'WSDC';
     FTypes[1]:= 'TEXT';

     IF Length(InName) > 0 THEN
     BEGIN
        FileReply.fName:= inName;
        FileReply.vRefNum:= inVol;
        FileReply.Good:= TRUE;
        OpenSelect:= 1;
     END
     ELSE SFPGetFile(P,' ',@ImpFilter,2,FTypes,@ImpGET,FileReply,OpenDLG,NIL);

     IF FileReply.Good  { If accepted } THEN
     BEGIN
        FileName:= FileReply.fName;
        fVol:= FileReply.vRefNum;

        IF OpenSelect = 2   { IF TEXT FILE }
        THEN
        BEGIN
            IF NOT GetWrapType THEN EXIT(OpenFile);

            SetMouse(4);

        { See if line edit mode }

            IF DefFlags = NoWrap { IF LINE-EDIT }
            THEN
            BEGIN
               MakeMonaco(Fmt);
               OpenMain(NIL,@Fmt);
            END
            ELSE OpenMain(NIL,NIL);

            Error:= FSOpen(FileName,fVol,fRef);
            Error:= GetEOF(fRef,fSize);         { Get logical file size }

            cDataHandle:= NewHandle(fSize);
            HLOCK(cDataHandle);

            Error:= FSRead(fRef,fSize,Pointer(@cDataHandle^^));
            HUNLOCK(cDataHandle);

            Error:= FSClose(fRef);

            SetPort(MainWindow);

            WSSetText(WS,cDataHandle);
            DisposHandle(cDataHandle);
        END
        ELSE
        BEGIN

            SetMouse(4);

            Error:= FSOpen(FileName,fVol,fRef);

            Error:= GetEOF(fRef,fSize);         { Get logical file size }

            DataHandle:= NewHandle(fSize);
            HLOCK(DataHandle);

            Error:= FSRead(fRef,fSize,Pointer(@DataHandle^^));
            HUNLOCK(DataHandle);

            Error:= FSClose(fRef);

            WS:= HandleToWS(DataHandle);    { Turn it into a WSHandle }
            DisposHandle(DataHandle);

            OpenMain(WS,NIL);
            SetWTitle(MainWindow,FileName);  { Show new title }
            CurWS.vRef:= fVol;

 { Determine scroll positions }

            WSGetScrollState(WS,CurWS.hOffset,CurWS.vOffset);

            x:= CurWS.vOffset DIV 8;
            SetCTLValue(CurWS.vCTL,X);
            X:= CurWS.hOffset DIV 8;
            SetCTLValue(CurWS.hCTL,X);
        END;

        SetPort(MainWindow);
        SetMyWS(MainWindow);

        OpenFile:= TRUE;
        ForceUpdate;
        GetMyWS(FrontWindow);
        SetMaxScroll;
        ShowControl(CurWS.vCTL);
        ShowControl(CurWS.hCTL);
     END
     ELSE OpenFile:= FALSE;
 END;


{ SAVE FILE ROUTINES }

 FUNCTION SaveFile(fVol:Integer):Boolean;

 VAR FileReply:SFREPLY;
     P:Point;
     FileName:STR255;
     DataHandle:Handle;
     Error,Error1,Error2,fRef:Integer;
     FSize:LongInt;

 BEGIN
      CaretOff;

      GetWTitle(MainWindow,FileName);       { Get file "name" }
      FileReply.fName:= FileName;       { Assume a mere SAVE }

      IF fVol = 0  { If this is a new guy } THEN
      BEGIN
         P.H:= 80;
         P.V:= 100;
         CaretOff;
         SFPutFile(P,'Save Document As:',FileName,NIL,FileReply);
         fVol:= FileReply.vRefNum;
      END
      ELSE FileReply.Good:= TRUE;   { Fake out the "ACCEPT" }

      IF FileReply.Good THEN
      BEGIN
         ForceUpdate;
         GetMyWS(FrontWindow);
         SetMouse(4);
         DataHandle:= WSToHandle(WS);     { Get a handle structure }

         IF OpFailed THEN
         BEGIN
            SaveFile:= FALSE;
            EXIT(SaveFile);
         END;

         FileName:= FileReply.fName;

         Error:= FSDelete(FileName,fVol);  { Delete any old }
         Error:= Create(FileName,fVol,'WSDP','WSDC');
         Error:= FSOpen(FileName,fVol,fRef);

         fSize:= GetHandleSize(DataHandle);    { Size of handle }
         HLOCK(DataHandle);               { Lock down for write }

         Error1:= FSWRITE(fRef,fSize,Pointer(@DataHandle^^));

         DisposHandle(DataHandle);
         Error2:= FlushVol(NIL,fVol);

         Error:= FSCLOSE(fRef);

         InitCursor;

         IF (Error1 = 0) AND (Error2 = 0)  { If no file errors }
         THEN
         BEGIN
            SetWTitle(MainWindow,FileName);  { Show new title }
            CurWS.vRef:= fVol;
            CurWS.Change:= FALSE;
            SetMyWS(MainWindow);
         END
         ELSE FileReply.Good:= FALSE;
      END;

      SaveFile:= FileReply.Good;
 END;


FUNCTION CloseMain:Boolean;
VAR TempWS:MyWSPtr;
    io:Integer;

BEGIN
   CloseMain:= FALSE;                { Assume not OK to close }
   IF CurWS.Change
   THEN
   BEGIN
      CaretOff;
      SetMouse(0);
      io:= CautionAlert(SaveChanges,NIL);

      ForceUpdate;
      GetMyWS(FrontWindow);

      IF io = 1  { "YES" }
      THEN
      BEGIN
         IF NOT SaveFile(CurWS.vRef)
         THEN EXIT(CloseMain);
      END
      ELSE
      IF io = 2  { "CANCEL" }
      THEN EXIT(CloseMain);
   END;

   CloseMain:= TRUE;
   WSDispose(WS);
   TempWS:= MyWSPtr(GetWRefCon(MainWindow));
   DisposPtr(Ptr(TempWS));
   DisposeWindow(MainWindow);
   MainWindow:= NIL;
END;



  {  PRINT ROUTINE }


 Procedure PrintWS(WS:WSHandle);
 VAR PageRect:Rect;
     Position:LongInt;

 BEGIN
    PageRect:= PHDL^^.PrInfo.rPage;

     PrintPort:= PrOpenDoc(PHDL,NIL,NIL);

    CXL:= FALSE;

    PrSetError(0);

    REPEAT
       PrOpenPage(PrintPort,NIL);
       Position:= WSPrint(WS,Position,PageRect);
       IF PrError = 128 THEN CXL:= TRUE;
       PrClosePage(PrintPort);
    UNTIL (Position = -1) OR (CXL);

    PrCloseDoc(PrintPort);

    IF NOT CXL THEN PrPicFile(PHDL,NIL,NIL,NIL,PStatus);
 END;


 {  MENUS }


 PROCEDURE DoFileMenu (Item:Integer);
 VAR Dummy,OK2Quit:Boolean;
     W:WindowPtr;
     Fmt:FormatRec;

 BEGIN
    GetMyWS(FrontWindow);

    Case Item OF

      1: { NEW }
            BEGIN
             IF NOT GetWrapType THEN EXIT(DoFileMenu);
             IF DefFlags = NoWrap
             THEN
             BEGIN
                MakeMonaco(Fmt);
                OpenMain(NIL,@Fmt);
             END
             ELSE OpenMain(NIL,NIL);

             ForceUpdate;
             GetMyWS(FrontWindow);
             SetMaxScroll;
             ShowControl(CurWS.vCTL);
             ShowControl(CurWS.hCTL);
          END;

      2: { OPEN } Dummy:= OpenFile('',0);

      3: { CLOSE } IF MainWindow <> NIL THEN Dummy:= CloseMain;

      4: { Save } Dummy:= SaveFile(CurWS.vRef);

      5: { Save As } Dummy:= SaveFile(0);

      7: { Import Text File } DoImport;

      8: { Save As Text } DoExport;

      10: { Page Setup }
          BEGIN
             ReHabPrint;
             SetMouse(0);
             Dummy:= PrStlDialog(PHDL);
          END;

      11: { Print }
          BEGIN
             ReHabPrint;
             SetMouse(0);
             IF PrJobDialog(PHDL)
             THEN
             BEGIN
                SetMouse(4);
                ForceUpdate;
                GetMyWS(FrontWindow);
                PrintWS(WS);
             END;
          END;

      13: BEGIN
             OK2Quit:= FALSE;
               REPEAT
                GetMyWS(FrontWindow);
                IF MainWindow = NIL
                THEN OK2Quit:= TRUE
                ELSE IF NOT CloseMain THEN EXIT(DoFileMenu);   { Audios }
                ForceUpdate;
             UNTIL OK2Quit;
             IF What4Scrap THEN
             BEGIN
                WSShutDown;
                ExitToShell;
             END;
          END;
    End;
 END;


 PROCEDURE DoFontMenu (Item:Integer);
 VAR fStr:STR255;

 BEGIN
    GetMyWS(FrontWindow);
    IF MainWindow = NIL THEN EXIT(DoFontMenu);

    SetFontUndo;                        { Establish an UNDO for this }

    GetItem(Menu3,Item,fStr);            { Return the actual font name }
    IF WSSetFont(WS,fStr)                { If needs rebuild .. }
       THEN ReDisplay;                    { Recalc/Redisplay }

    SetChanges(TRUE);
 END;



 FUNCTION MakeYourOwn:Integer;
 VAR V:Integer;
    PS:Fixed;

    BEGIN
       IF WSGetPoint(WS,PS)
       THEN V:= HiWord(LongInt(PS))
       ELSE V:= 12;
       IF NumDialog(PtSizeDLG,V)
       THEN MakeYourOwn:= V
       ELSE MakeYourOwn:= 0;

       SetPort(MainWindow);
    END;



 PROCEDURE DoPointMenu (Item:Integer);
 VAR PF:Fixed;
      P:Integer;

 BEGIN
    GetMyWS(FrontWindow);
    IF MainWindow = NIL THEN EXIT(DoPointMenu);

    SetFontUndo;

    CASE Item OF

       1: P:= 6;
       2: P:= 9;
       3: P:= 10;
       4: P:= 12;
       5: P:= 14;
       6: P:= 16;
       7: P:= 18;
       8: P:= 20;
       9: P:= 22;
       10: P:= 24;
       11: P:= MakeYourOwn;
   END;

   IF P > 0 THEN
   BEGIN
      PF:= FixRatio(P,1);    { Make a whole amount }
      IF WSSetPoint(WS,PF) THEN Redisplay;
      SetChanges(TRUE);

   END;
 END;



 PROCEDURE DoEditMenu (Item:Integer);
 VAR Dummy:Boolean;
     Sel1,Sel2:LongInt;
     TempFonts:FormatHandle;

    PROCEDURE UndoClear;
    BEGIN
         IF UndoWS = NIL THEN EXIT(UndoClear);

         SetMouse(4);
         WSSetSelect(WS,CurWS.UnSel1,CurWS.UnSel1,FALSE);
         Dummy:= WSPaste(UndoWS,WS);
         IF OpFailed THEN EXIT(UndoClear);
         WSDispose(UndoWS);            { Remove Undo }
         UndoWS:= NIL;
         ReDisplay;
         WSSetSelect(WS,CurWS.UnSel1,CurWS.UnSel2,TRUE);
         CurWS.Undo:= 0;
    END;

    PROCEDURE UndoPaste;
      BEGIN
         SetMouse(4);
         WSSetSelect(WS,CurWS.UnSel1,CurWS.UnSel2,FALSE);
         Dummy:= WSCut(WS);
         CurWS.Undo:= 0;
         ReDisplay;
         ForceScroll;
      END;


 BEGIN
    GetMyWS(FrontWindow);
    IF MainWindow = NIL THEN
    BEGIN
       IF Item < 7 THEN Dummy:= SystemEdit(Item-1)
       ELSE
       IF Item = 9 THEN ShowClipBoard;
    END
    ELSE
    BEGIN
        IF Item > 1 { IF NOT NOW 'UNDO' }
        THEN WSGetSelect(WS,CurWS.unSel1,CurWS.unSel2);        { Get selection }

        CASE Item OF

          1:  { Undo }
              BEGIN
                 IF CurWS.Undo < 8 { If one of my EDIT items }
                 THEN
                 BEGIN
                    CASE CurWS.Undo OF

                       1: { Format UNDO }
                          BEGIN
                             SetMouse(4);
                             TempFonts:= WSCopyFormat(WS);    { Get THIS format }
                             IF OpFailed THEN EXIT(DoEditMenu);
                             WSSetSelect(WS,CurWS.UnSel1,CurWS.UnSel2,FALSE);
                             WSApplyFormat(WS,FontScrap);
                             DisposHandle(Handle(FontScrap));
                             FontScraP:= TempFonts;
                             CurWS.Undo:= 1;        { Same as before }
                             WSBitMapDisplay(WS,0,SrcCopy,TRUE);
                          END;

                       2: { Undo Import } UndoPaste;

                       3: { Undo Cut }
                          BEGIN
                               SetMouse(4);
                             WSSetSelect(WS,CurWS.UnSel1,CurWS.UnSel1,FALSE);
                             Dummy:= WSPaste(ScrapWS,WS);
                             IF OpFailed THEN EXIT(DoEditMenu);
                             WSSetSelect(WS,CurWS.UnSel1,CurWS.UnSel2,FALSE);
                             WSDispose(ScrapWS);        { Remove scrap }
                             ScrapWS:= UndoWS;            { Old scrap }
                             UndoWS:= NIL;
                             CurWS.Undo:= 5;            { Next time undo PASTE }
                             ReDisplay;
                             InvalScrap;
                          END;

                       4: { Undo Copy }
                          BEGIN
                             WSSetSelect(WS,CurWS.UnSel1,CurWS.UnSel2,TRUE);
                             WSDispose(ScrapWS);
                             ScrapWS:= UndoWS;
                             UndoWS:= NIL;
                             CurWS.Undo:= 0;  { Don't know how to undo this }
                             InvalScrap;
                          END;

                       5: { Undo Paste } UndoPaste;

                       6: { Undo Clear }
                             BEGIN
                                 UndoClear;
                              CurWS.Undo:= 0;
                          END;

                       7: { Undo SelectAll }
                          BEGIN
                             WSSetSelect(WS,CurWS.UnSel1,CurWS.UnSel2,TRUE);
                             CurWS.Undo:= 0;
                          END;
                       END;
                     END
                     ELSE
                     BEGIN
                { A KEYSTROKE 'UNDO' }
                        IF CurWS.UnSel1 <> CurWS.UnSel2  { If there was a selection }
                        THEN
                        BEGIN
                           IF CurWS.Undo <> 8 { If not backspace }
                           THEN
                           BEGIN
                              EV.Message:= 8;
                              WSKey(WS,EV);  { Fake a backspace }
                           END;
                           UndoClear;
                        END
                        ELSE
                        BEGIN
                { No selection }
                           WSGetSelect(WS,CurWS.UnSel1,CurWS.UnSel2);
                           IF CurWS.UnSel1 <> CurWS.UnSel3
                           THEN
                           BEGIN
                              WSSetSelect(WS,CurWS.unSel3,CurWS.UnSel1,FALSE);
                              IF UndoWS <> NIL THEN WSDispose(UndoWS);
                              UndoWS:= WSCopy(WS);        { Copy keys to be deleted }
                              Dummy:= WSCut(WS);
                              ReDisplay;
                              CurWS.Undo:= 6;            { Pretend a CLEAR }
                              WSGetSelect(WS,CurWS.UnSel1,CurWS.UnSel2);
                           END;
                        END;
                     END;

                 SetChanges(TRUE);
              END;


          3:  { Cut }
              BEGIN
                 SetMouse(4);
                 IF UndoWS <> NIL THEN WSDispose(UndoWS);
                 UndoWS:= ScrapWS;
                 ScrapWS:= WSCopy(WS);
                 IF OpFailed
                 THEN
                 BEGIN
                    OpFailed:= FALSE;        { So it doesn't re-alert }
                    SetMouse(0);
                    CurWS.Undo:= 0;
                    SetMyWS(MainWindow);
                    CaretOff;
                    io:= CautionAlert(CantUndo,NIL);
                    IF io = 1 THEN EXIT(DoEditMenu);
                    SetPort(MainWindow);
                 END
                 ELSE CurWS.Undo:= 3;

                 MyOwnScrap:= TRUE;

                 IF WSCut(WS) THEN ReDisplay;
                 SetChanges(TRUE);
                 ForceScroll;
                 InvalScrap;
              END;

          4:  { Copy }
              BEGIN
                 SetMouse(4);
                 IF UndoWS <> NIL THEN WSDispose(UndoWS);
                 UndoWS:= ScrapWS;            { Copy the scrap }
                 ScrapWS:= WSCopy(WS);
                 IF OpFailed THEN EXIT(DoEditMenu);
                 MyOwnScrap:= TRUE;
                 InvalScrap;
                 CurWS.Undo:= 4;
                 SetMyWS(MainWindow);
              END;

          5:  { Paste }
              BEGIN
                  GetXScrap;                { Get any external scrap }
                  IF ScrapWS <> NIL
                  THEN
                  BEGIN
                     SetMouse(4);
                     IF WSPaste(ScrapWS,WS) THEN ReDisplay;
                     IF OpFailed THEN EXIT(DoEditMenu);
                     CurWS.Undo:= 5;
                     WSGetSelect(WS,Sel1,CurWS.unSel2);  { So I can undo paste }
                     SetChanges(TRUE);
                     ForceScroll;
                  END;
              END;

          6:  { Clear }
              BEGIN
                 SetMouse(4);
                 IF UndoWS <> NIL THEN WSDispose(UndoWS);
                 UndoWS:= WSCopy(WS);

                 IF OpFailed
                 THEN
                 BEGIN
                    OpFailed:= FALSE;        { So it doesn't re-alert }
                    SetMouse(0);
                    CurWS.Undo:= 0;
                    SetMyWS(MainWindow);
                    CaretOff;
                    io:= CautionAlert(CantUndo,NIL);
                    IF io = 1 THEN EXIT(DoEditMenu);
                    SetPort(MainWindow);
                 END
                 ELSE CurWS.Undo:= 6;

                 IF WSCut(WS) THEN ReDisplay;
                 SetChanges(TRUE);
                 ForceScroll;
              END;

          7:  { Select All }
              BEGIN
                   WSSetSelect(WS,0,10000000,TRUE);
                 CurWS.Undo:= 7;
                 SetMyWS(MainWindow);
              END;

          9:  ShowClipBoard;

        END;

    END;
 END;



 PROCEDURE PickColor;
 VAR InColor,OutColor:RGBColor;
     Title:STR255;
     P:Point;
     AnyColor:Integer;

 BEGIN
    IF NOT WSGetColor(WS,inColor)
    THEN
    BEGIN
        inColor.Red:= 0;
        inColor.Green:= 0;
        inColor.Blue:= 0;
    END;

    P.H:= 0;
    P.V:= 0;

    Title:= 'Choose Text Color:';

    IF GetColor(P,Title,InColor,OutColor)
    THEN
    BEGIN
       ForceUpdate;
       SetMyWS(FrontWindow);
       SetFontUndo;
       IF WSSetColor(WS,OutColor) THEN ReDisplay;
       SetChanges(TRUE);
    END;
 END;



 PROCEDURE DoStyleMenu (Item:Integer);
 VAR TheStyle:Integer;
     SetStyle1,SetStyle2:Boolean;

 BEGIN
    GetMyWS(FrontWindow);
    IF MainWindow = NIL THEN EXIT(DoStyleMenu);

    IF Item = 10 { Set Color } THEN PickColor
    ELSE
    BEGIN
        SetFontUndo;

        CASE Item OF

           1: TheStyle:= 0;        { Plain }
           2: TheStyle:= 1;
           3: TheStyle:= 2;
           4: TheStyle:= 4;
           5: TheStyle:= 8;
           6: TheStyle:= 16;
           7: TheStyle:= 32;
           8: TheStyle:= 64;
           9: TheStyle:= 128;
        END;

        SetStyle1:= WSSetStyle(WS,TheStyle);
        SetStyle2:= FALSE;

        IF TheStyle = 0  { If this was "plain" }
        THEN SetStyle2:= WSSetUserStyle(WS,NIL,0,0);   { Clear UserProcs }

        IF (SetStyle1) OR (SetStyle2) THEN ReDisplay;
        SetChanges(TRUE);
    END;
 END;


 PROCEDURE DoFormatMenu (Item:Integer);
 VAR SM:LongInt;
     err:OSErr;
 BEGIN
    GetMyWS(FrontWindow);
    IF MainWindow = NIL THEN EXIT(DoFormatMenu);
    WSSetJust(WS,Item-1);
    WSDisplay(WS,0,TRUE,TRUE);
    SetChanges(TRUE);
 END;





 PROCEDURE DoDemoMenu(Item:Integer);
 var test1,test2:integer;
      test3:LongInt;
     TBuf:TextBlock;
     WG:WSGlobals;
     r:LongRect;

 BEGIN
    GetMyWS(FrontWindow);
    IF MainWindow = NIL THEN EXIT(DoDemoMenu);

    Case Item OF

          1: io:= Alert(AddOnAlert,NIL);

    END;

 END;


 PROCEDURE DoMenus(MResult:LongInt);
 VAR io,Item:Integer;
     MenuStr:STR255;


 BEGIN
    Item:= LOWORD(MResult);

    CASE HiWord(MResult) OF

         1: { DA's }
            BEGIN
               IF Item = 1 THEN io:= Alert(AboutAlert,NIL)
               ELSE
               BEGIN
                  PutXScrap;            { Load external scrap }
                  GetItem(Menu0,Item,MenuStr);
                  io:= OpenDeskAcc(MenuSTR);
               END;
            END;


       100: DoFileMenu(Item);        { FILE }


       200: DoEditMenu(Item);        { EDIT }


       300: DoFontMenu(Item);        { FONT }


       400: DoStyleMenu(Item);        { STYLE }


       500: DoPointMenu(Item);        { Point size }


       600: DoFormatMenu(Item);        { FORMAT }


       700: DoDemoMenu(Item);        { Special demo stuff }


    END;


    HILITEMENU(0);     { Remove menu hilites }
 END;




 PROCEDURE DoKey;
 VAR KChar:Char;
     forMenus,bSel,eSel:LongInt;
     PrevFail:Boolean;

        FUNCTION AnArrowKey:Boolean;
        BEGIN
           IF (BitAnd(LoWord(EV.Message),255) >27)
           AND (BitAnd(LoWord(EV.Message),255) <32)
           THEN AnArrowKey:= TRUE
           ELSE AnArrowKey:= FALSE;
        END;

 BEGIN

 { Meant for WS }

      IF BitAnd(EV.Modifiers,256) = 256  { IF COMMAND KEY DOWN }
      THEN
      BEGIN
         MenuEnable;          { Enable / Disable appropriate Menu items }
         KChar:= CHR(LoWord(EV.Message));
         forMenus:= MenuKey(KChar);
         DoMenus(forMenus);
      END
      ELSE
      BEGIN
          GetMyWS(FrontWindow);
          IF MainWindow <> NIL THEN
          BEGIN
             ObscureCursor;

             IF BitAnd(LoWord(EV.Message),255) = 3  { IF ENTER KEY }
             THEN EV.Message:= 10;

             WSGetSelect(WS,CurWS.unSel1,CurWS.unSel2);
                                     { To see if there's a selection }

             IF (CurWS.unSel1 <> CurWS.unSel2)
             AND (NOT AnArrowKey) { If a selection }
             THEN
             BEGIN
                SetMouse(4);
                IF UndoWS <> NIL THEN WSDispose(UndoWS);    { Remove UNDO }
                UndoWS:= WSCopy(WS);                        { Copy for UNDO }
                PrevFail:= OpFailed;
                IF OpFailed
                THEN
                BEGIN
                    OpFailed:= FALSE;        { So it doesn't re-alert }
                    SetMouse(0);
                    CurWS.Undo:= 0;
                    SetMyWS(MainWindow);
                    CaretOff;
                    io:= CautionAlert(CantUndo,NIL);
                    IF io = 1 THEN EXIT(DoKey);
                    SetPort(MainWindow);
                END;

                IF WSCut(WS) THEN ReDisplay;

                IF (BitAnd(LoWord(EV.Message),255) <> 8)  { If not a backspace }
                    OR (CharByte(Ptr(@EV.Message),0) <> 0) { Or 2 byte char}
                THEN WSKey(WS,EV);
             END
             ELSE WSKey(WS,EV);

             IF NOT PrevFail
             THEN CurWS.Undo:= BitAnd(LoWord(EV.Message),255) { Save the key as UNDO }
             ELSE CurWS.Undo:= 0;

             IF NOT AnArrowKey THEN SetChanges(TRUE);
             ForceScroll;
         END;
     END;
 END;


 PROCEDURE DoUpdate;
 VAR WhatWindow:WindowPtr;
     R:Rect;

 BEGIN
     WhatWindow:= WindowPtr(EV.Message);
     GetMyWS(WhatWindow);

     BeginUpdate(WhatWindow);
     SetPort(WhatWindow);
     EraseRect(WhatWindow^.PortRect);
     IF MainWindow <> NIL
     THEN
     BEGIN
        WSDisplay(WS,0,FALSE,TRUE);
        DrawGrowIcon(MainWindow);
        DrawControls(MainWindow);
        LastNumChars:= -1;
        ShowNumChars;
     END
     ELSE
     IF WhatWindow = ClipWindow
     THEN
     BEGIN
        GetXScrap;                            { Get possible external scrap }
        IF ScrapWS <> NIL
        THEN
        BEGIN
 { Display the scrap }
           R:= ClipWindow^.PortRect;        { Start with whole screen }
           InsetRect(R,4,2);                { Inset a wee bit }
           ScrapWS^^.tBounds.Top:= R.Top;    { Force bounds to wrap properly }
           ScrapWS^^.tBounds.Bottom:= R.Bottom;
           ScrapWS^^.tBounds.Left:= R.Left;
           ScrapWS^^.tBounds.Right:= R.Right;
           ScrapWS^^.tRect:= R;                { View is the same }
           WSDisplay(ScrapWS,0,TRUE,FALSE);
        END;
     END;

     EndUpdate(WhatWindow);
 END;



 PROCEDURE MyAction (WhatCTL:ControlHandle; Part:Integer);
 VAR H,V:LongInt;

 BEGIN
    H:= 0;
    V:= 0;

    IF WhatCTL = CurWS.vCTL  { If vertical scroll }
    THEN
    BEGIN
       Case Part OF
          inUpButton:     { Scroll UP }    V:= 16;

          inDownButton: { Scroll down } V:= -16;

          inPageUp:     { Page up }        V:= WS^^.tRect.Bottom-WS^^.tRect.Top;

          inPageDown:     { Page down }    V:= WS^^.tRect.Top-WS^^.tRect.Bottom;

       END; { of case }
    END
    ELSE
    BEGIN
      { Horizontal scroll }

       Case Part OF
          inUpButton:     { Scroll UP }    H:= 16;

          inDownButton: { Scroll down } H:= -16;

          inPageUp:     { Page up }        H:= WS^^.tRect.Right-WS^^.tRect.Left;

          inPageDown:     { Page down }    H:= WS^^.tRect.Left-WS^^.tRect.Right;

       END; { of case }
    END;

    MasterScroll(H,V);
 END;


 FUNCTION ScrollWindow:Boolean;
 VAR P:Point;
       WhatCTL:ControlHandle;
      Part,FinalPart,FirstValue:Integer;
      H,V,Work,Zero:LongInt;
 BEGIN
    P:= EV.Where;                { Global mouse }
    GlobalToLocal(P);
    Part:= FindControl(P,MainWindow,WhatCTL);
    IF Part = 0 THEN ScrollWindow:= FALSE
    ELSE
    BEGIN
       ScrollWindow:= TRUE;
       SetMouse(0);

       FirstValue:= GetCTLValue(WhatCTL);

       IF Part = inThumb
       THEN FinalPart:= TrackControl(WhatCTL,P,NIL)
       ELSE FinalPart:= TrackControl(WhatCTL,P,@MyAction);

       IF FinalPart = inThumb
       THEN
       BEGIN
          Zero:= 0;
          Part:= GetCTLValue(WhatCTL);
          IF Part > FirstValue  { If thumb = DOWN }
          THEN
          BEGIN
             Work:= Part-FirstValue;
             Work:= Work*8;
             Work:= Zero-Work;        { Makes it negative }
          END
          ELSE
          BEGIN
             Work:= FirstValue-Part;
             Work:= Work*8;
          END;

          H:= 0;
          V:= 0;
          IF WhatCTL = CurWS.vCTL
          THEN V:= Work ELSE H:= Work;
          MasterScroll(H,V);
       END;
    END;
 END;


 { THE FOLLOWING IS A DEMO OF AUTOMATICALLY SCROLLING WITH WS-0 }
 PROCEDURE MyIdleProc (WS:WSHandle; NewMouse:Point);
 VAR H,V:LongInt;

 { Note that outside routines will work since global "WS" has been set prior
   to mouse dragging began }

 BEGIN
    H:= 0;                    { Assume no H-SCROLL }
    V:= 0;                    { Assume no V-SCROLL }

    IF NewMouse.V < WS^^.tRect.Top  { If mouse is ABOVE view }
    THEN V:= 16                { Scroll up a bit }
    ELSE
    IF NewMouse.V > WS^^.tRect.Bottom { If mouse below view }
    THEN V:= -16;            { Scroll down a bit }

    IF NewMouse.H < WS^^.tRect.Left  { If mouse is left of view }
    THEN H:= 16                { Scroll forward a bit }
    ELSE
    IF NewMouse.H > WS^^.tRect.Right { If mouse right of view }
    THEN H:= -16;            { Scroll back a bit }

    IF (H <> 0) OR (V <> 0)   { If I have a scrolling situation }
    THEN MasterScroll(H,V);

 END;


 PROCEDURE DoClick;
 VAR WhatWindow: WindowPtr;       { Window in questions }
     Contact,FW:Integer;
     forMenus,forGrow:LongInt;
     R:Rect;
     Dummy:Boolean;
     P:Point;

 BEGIN
    FW:= FindWindow (EV.Where,WhatWindow);
    GetMyWS(WhatWindow);

    CASE FW OF

       inMenuBar:
               BEGIN
              MenuEnable;
              MarkMenus;
              SetMouse(0);
              forMenus:= MenuSelect(EV.Where);
              DoMenus(forMenus);
            END;

       inSysWindow:
            SystemClick(EV,WhatWindow);

       inContent:
            IF MainWindow <> NIL THEN
            BEGIN
               IF MainWindow <> FrontWindow
               THEN SelectWindow(MainWindow)
               ELSE
               BEGIN
                  SetPort(MainWindow);
                  P:= EV.Where;
                  GlobalToLocal(P);
                  IF (NOT ScrollWindow)
                             AND
                      (PtInRect(P,WS^^.tRect))
                  THEN
                  BEGIN
                      WSClick(WS,EV,@MyIdleProc);
                      WSGetSelect(WS,CurWS.UnSel3,CurWS.UnSel3);  { For key-Undo }
                      SetMyWS(MainWindow);
                  END;
               END;
            END
            ELSE
            IF WhatWindow = ClipWindow
            THEN SelectWindow(ClipWindow);

       inDrag:
               BEGIN
               SetRect(R,0,20,768,400);
               DragWindow (WhatWindow,EV.Where,R);
            END;

       inGrow:
           BEGIN
              IF MainWindow <> NIL
              THEN
              BEGIN
                 SetRect(R,0,0,4096,4096);
                 forGrow:= GrowWindow(MainWindow,EV.Where,R);
                 IF forGrow <> 0
                 THEN
                 BEGIN
                    KillControls(MainWindow);
                    SizeWindow(MainWindow,LoWord(forGrow),HiWord(forGrow),TRUE);
                    SetPort(MainWindow);
                    R:= MainWindow^.PortRect;
                    ClipRect(R);
                    InvalRect(R);

                    MakeNewControls(MainWindow);

                    R:= MainWindow^.PortRect;
                    R.Right:= CurWS.vCTL^^.contrlRect.Left;
                    R.Bottom:= CurWS.hCTL^^.contrlRect.Top;
                    WS^^.tRect:= R;
                    SetMyWS(MainWindow);
                    ForceUpdate;
                    GetMyWS(FrontWindow);
                    SetMaxScroll;
                    ShowControl(CurWS.vCTL);
                    ShowControl(CurWS.hCTL);
                    LastNumChars:= -1;
                    ShowNumChars;
                 END;
              END;
           END;

       inGoAway:
           BEGIN
              IF TrackGoAway(WhatWindow,EV.Where)
              THEN
              BEGIN
                 IF WhatWindow = MainWindow THEN Dummy:= CloseMain
                 ELSE
                 IF WhatWindow = ClipWindow
                 THEN
                 BEGIN
                    DisposeWindow(ClipWindow);
                    ClipWindow:= NIL;
                 END;
              END;
           END;


    END;  { of FindWindow }

 END;



 PROCEDURE DoActivate;
 BEGIN
    GetMyWS(WindowPtr(EV.Message));

    IF MainWindow <> NIL
    THEN
    BEGIN
       SetPort(MainWindow);
       IF BitAnd(EV.Modifiers,1) = 1
       THEN WSActivate(WS)
       ELSE WSDeactivate(WS);
       DrawGrowIcon(MainWindow);
       DrawControls(MainWindow);    { Assure controls come out right }
       LastNumChars:= -1;
       ShowNumChars;
    END;
 END;


 PROCEDURE ForceUpdate;   { Forces update & activate events }
 VAR Cont:Boolean;

 BEGIN
    Cont:= TRUE;
    REPEAT
        IF GetNextEvent(EveryEvent,EV)
        THEN
        BEGIN
           Case EV.What OF
              updateEvt: DoUpdate;
              activateEvt: DoActivate;
           END;
           SystemTask;
           IF EV.What = 0 THEN Cont:= FALSE;
        END
        ELSE Cont:= FALSE;
    UNTIL NOT Cont;

 END;


 FUNCTION MemErrProc (cNeeded:LongInt):Boolean;
 VAR Result:Integer;
     TakenFree:LongInt;
 BEGIN
    MemErrProc:= FALSE;                    { Don't even try it... }
    IF cNeeded < 0  { If this is NO RETURN ERROR }
    THEN
    BEGIN
       SetMouse(0);
       io:= CautionAlert(StupidTester,NIL);
    END
    ELSE OpFailed:= TRUE;
 END;


{ START }
BEGIN
     InitGraf(@ThePort);
     InitFonts;
     InitWindows;
     InitMenus;
     InitDialogs(NIL);
     TEInit;

     PHDL:= THPrint(NewHandle(120));
     PrOpen;
     PrintDefault(PHDL);    { Set default print record }

     AppleChar:= ' ';
     AppleChar[1]:= CHR(20);

     Menu0:= NewMenu(1,Applechar);      { Make a DA menu }
     AppendMenu(Menu0,'About This Demo');
     AppendMenu(Menu0,'(-');

     AddResMenu(MENU0,'DRVR');

     Menu3:= NewMenu(300,'Font');       { Get all fonts }
     AddResMenu(Menu3,'FONT');

  { Get the rest of the menus: }

     MENU1:= GetMenu(100);
     MENU2:= GetMenu(200);
     MENU4:= GetMenu(400);
     MENU5:= GetMenu(500);
     MENU6:= GetMenu(600);
     MENU7:= GetMenu(700);

     InsertMenu(MENU0,0);
     InsertMenu(MENU1,0);
     InsertMenu(MENU2,0);
     InsertMenu(MENU3,0);
     InsertMenu(MENU4,0);
     InsertMenu(MENU5,0);
     InsertMenu(MENU6,0);
     InsertMenu(MENU7,0);

     DrawMenuBar;

     ClipWindow:= NIL;            { Clipboard not open }
     ScrapWS:= NIL;                { Scrap not open }
     UndoWS:= NIL;                { Undo doesn't exist }
     FontScrap:= NIL;            { Font Scrap doesn't exist either }

     WSStartup(128,@MemErrProc);

{ Now obtain any external scrap }

     XScrap:= InfoScrap;
     MyScrapNum:= XScrap^.scrapCount-1;        { So I think there's scrap }
     GetXScrap;                                { Return it. }
     MyOwnScrap:= FALSE;

     MainWindow:= NIL;
     LastNumChars:= -1;
     ShowCtr:= 0;
     OpFailed:= FALSE;
     OpenSelect:= 1;
     DefFlags:= 0;

     CountAppFiles(AppMsg,nFiles);

     IF nFiles > 0 THEN
     BEGIN
        GetAppFiles(1,AppData);
        Quit:= OpenFile(AppData.fName,AppData.vRefNum);
        ForceUpdate;
     END
     ELSE
     BEGIN
         OpenMain(NIL,NIL);
         ForceUpdate;
         GetMyWS(FrontWindow);
         SetMaxScroll;
         ShowControl(CurWS.vCTL);
         ShowControl(CurWS.hCTL);
     END;

     InitCursor;
     CurCursor:= 0;
     QUIT:= FALSE;
     io:= Alert(AboutAlert,NIL);

     REPEAT
        IF OpFailed  { If recent operation failed }
        THEN
        BEGIN
           SetMouse(0);
           io:= CautionAlert(MemFailed,NIL);
           OpFailed:= FALSE;
        END;

        SystemTask;

        IF GetNextEvent(EveryEvent,EV) THEN
        BEGIN

           CASE EV.What OF

              mouseDown: DoClick;

              keyDown: REPEAT
                         DoKey;
                       UNTIL NOT GetNextEvent(KeyDownMask+AutoKeyMask,EV);


              autoKey: REPEAT
                         DoKey;
                       UNTIL NOT GetNextEvent(KeyDownMask+AutoKeyMask,EV);

              updateEvt: DoUpdate;

              activateEvt: DoActivate;

           END; { of possible Events }

        END
        ELSE
        BEGIN
            GetMyWS(FrontWindow);
            IF MainWindow <> NIL THEN
            BEGIN
               SetPort(MainWindow);
               WSIdle(WS);
               GetMouse(LocalMouse);
               IF PtInRect(LocalMouse,WS^^.tRect)
               THEN SetMouse(iBeamCursor)
               ELSE SetMouse(0);
               ShowCtr:= ShowCtr-1;
               IF ShowCtr < 0 THEN
               BEGIN
                  ShowNumChars;
                  ShowCtr:= 32;
               END;
            END;
        END;
     UNTIL QUIT;

     ExitToShell;
END.